/**
 * 对称之美
 *
 * 题目描述
 * 给出n个字符串，从第1个字符串一直到第n个字符串每个串取一个字母来构成一个新字符串，
 * 新字符串的第i个字母只能从第i行的字符串中选出，这样就得到了一个新的长度为n的字符串，
 * 请问这个字符串是否有可能为回文字符串？
 *
 * 输入描述:
 * 第一行一个数字 t,1≤t≤50,代表测试数据的组数
 * 每组测试数据先给出一个数字 n，然后接下来n行每行一个只由小写字母组成的字符串
 * si 1≤n≤100,1≤∣si∣≤50
 *
 * 输出描述:
 * 在一行中输出 “Yes” or “No”
 */

import java.util.Scanner;

/**
 * 这里我们需要判断是否可以组成回文数, 这里主要的使用就是
 * 从两边到中间的判断方法, 我们先拿出一边的字符, 加入 hash
 * 然后再去查看另一边是否有同样的字符, 要是有, 就说明这个位置
 * 是满足要求的, 就这样, 一直到两边相遇, 就是可以成功的组成回文串
 * 时间复杂度 : O(n)
 * 空间复杂度 : O(n)
 */

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        // 测试用例数
        int t = in.nextInt();

        while (t-- != 0) {

            int n = in.nextInt();

            String[] s = new String[n];

            for (int i = 0; i < n; i++) {
                s[i] = in.next();
            }

            // 两个边界数
            int left = 0, right = n - 1;

            // 相遇就出去
            while (left < right) {

                // hash 数组记录字符
                int[] hash = new int[26];

                // 左右两边的字符数组
                char[] c1 = s[left].toCharArray();
                char[] c2 = s[right].toCharArray();

                // 左边的加入 hash
                for (int i = 0; i < c1.length; i++) {
                    hash[c1[i] - 'a']++;
                }

                // 是否满足要求的标记
                boolean tmp = false;

                // 判断右边是否有同样的字符
                for (int i = 0; i < c2.length; i++) {

                    if (hash[c2[i] - 'a'] > 0) {

                        // 有的话更新标记
                        tmp = true;

                        // 并且跳出这次循环
                        break;
                    }
                }

                // 判断标记, 要是有一个不满足, 就直接不能满足题目条件了
                if (!tmp) {

                    // 直接出循环
                    break;
                }

                // 更新边界
                left++;
                right--;
            }

            // 最后的判断, 走到结束了就返回 Yes, 反之返回 No
            if (left < right) {
                System.out.println("No");
            } else {
                System.out.println("Yes");
            }
        }
    }

    // **************************************************************
    // 用常规数组进行hash优化
    public static void main2(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        while (t-- != 0) {
            int n = in.nextInt();

            boolean[][] hash = new boolean[n][26];
            for(int i = 0; i < n; i++) {
                char[] s = in.next().toCharArray();
                for(char ch : s) {
                    hash[i][ch - 'a'] = true;
                }
            }
            int left = 0, right = n - 1;
            while(left < right) {
                if(!check(hash, left, right)) {
                    break;
                }
                left++; right--;
            }
        }
    }

    public static boolean check(boolean[][] hash, int left, int right) {
        for(int i = 0; i < 26; i++) {
            if(hash[left][i] && hash[right][i]) return true;
        }
        return false;
    }
}